home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xmbase-grok-1.2 / printwin.c < prev    next >
C/C++ Source or Header  |  1995-06-25  |  10KB  |  320 lines
  1. /*
  2.  * Create and destroy the print popup, and call the printing functions.
  3.  * The configuration is stored in the pref structure, but it can be changed
  4.  * only here.
  5.  *
  6.  *    destroy_print_popup()
  7.  *    create_print_popup()
  8.  */
  9.  
  10. #include "config.h"
  11. #include <X11/Xos.h>
  12. #include <stdlib.h>
  13. #include <Xm/Xm.h>
  14. #include <Xm/DialogS.h>
  15. #include <Xm/Form.h>
  16. #include <Xm/LabelP.h>
  17. #include <Xm/LabelG.h>
  18. #include <Xm/PushBP.h>
  19. #include <Xm/PushBG.h>
  20. #include <Xm/ToggleB.h>
  21. #include <Xm/Separator.h>
  22. #include <Xm/RowColumn.h>
  23. #include <Xm/FileSB.h>
  24. #include <Xm/Protocols.h>
  25. #include "grok.h"
  26. #include "form.h"
  27. #include "proto.h"
  28.  
  29. static void cancel_callback    (Widget, int, XmToggleButtonCallbackStruct *);
  30. static void print_callback    (Widget, int, XmToggleButtonCallbackStruct *);
  31. static void config_callback    (Widget, int, XmToggleButtonCallbackStruct *);
  32. static void file_print_callback    (Widget,int,XmFileSelectionBoxCallbackStruct*);
  33. static void file_cancel_callback(Widget,int,XmFileSelectionBoxCallbackStruct*);
  34.  
  35. extern Display    *display;    /* everybody uses the same server */
  36. extern Pixel    color[NCOLS];    /* colors: COL_* */
  37. extern int    errno;
  38. extern Widget    toplevel;    /* top-level shell for error popup */
  39. extern struct    pref pref;    /* global preferences */
  40.  
  41. static BOOL    have_shell;    /* message popup exists if TRUE */
  42. static Widget    shell;        /* popup menu shell */
  43. static BOOL    modified;    /* preferences have changed */
  44.  
  45.  
  46. /*
  47.  * destroy popup. Remove it from the screen, and destroy its widgets.
  48.  */
  49.  
  50. void destroy_print_popup(void)
  51. {
  52.     if (have_shell) {
  53.         if (modified)
  54.             write_preferences();
  55.         XtPopdown(shell);
  56.         XtDestroyWidget(shell);
  57.         have_shell = FALSE;
  58.     }
  59. }
  60.  
  61.  
  62. /*
  63.  * create a print popup as a separate application shell. The popup is
  64.  * initialized with data from pref. The menu array is the template for
  65.  * generating the upper part of the popup window. The code is used to
  66.  * identify buttons in callbacks. Code bits 4..7 are used to group
  67.  * one-of-many choices.
  68.  */
  69.  
  70. static struct menu {
  71.     char    type;        /* L=label, R=RowColumn, C=choice */
  72.     long    code;        /* unique identifier, 0=none */
  73.     char    *ptr;        /* location in pref where value is stored */
  74.     char    value;        /* value stored in pref for each mode */
  75.     char    *text;
  76.     Widget    widget;
  77. } menu[] = {
  78.     { 'L',    0,    0,          0,    "Cards to print:"       },
  79.     { 'R',    0,    0,          0,    "rc1",               },
  80.     { 'C',    0x10,    &pref.pselect,     'C',    "Current only"           },
  81.     { 'C',    0x11,    &pref.pselect,     'S',    "Search or query"       },
  82.     { 'C',    0x12,    &pref.pselect,     'e',    "All cards in section"       },
  83.     { 'C',    0x13,    &pref.pselect,     'A',    "All cards"           },
  84.     { 'L',    0,    0,          0,    "Output format:"       },
  85.     { 'R',    0,    0,          0,    "rc2",               },
  86.     { 'C',    0x20,    &pref.pformat,     'S',    "Summary"           },
  87.     { 'C',    0x21,    &pref.pformat,     'N',    "Summary with notes"       },
  88.     { 'C',    0x22,    &pref.pformat,     'C',    "Cards"               },
  89.     { 'L',    0,    0,          0,    "Output quality:"       },
  90.     { 'R',    0,    0,          0,    "rc3",               },
  91.     { 'C',    0x30,    &pref.pquality,  'A',    "Low, ASCII only"       },
  92.     { 'C',    0x31,    &pref.pquality,  'O',    "Medium, overstrike ASCII" },
  93.     { 'C',    0x32,    &pref.pquality,  'P',    "High, PostScript"       },
  94.     { 'L',    0,    0,          0,    "Output device:"       },
  95.     { 'R',    0,    0,          0,    "rc4",               },
  96.     { 'C',    0x40,    &pref.pdevice,     'P',    "Printer"           },
  97.     { 'C',    0x41,    &pref.pdevice,     'F',    "File"               },
  98.     { 'C',    0x42,    &pref.pdevice,     'W',    "Window"           },
  99.     {  0,   0,    0,          0,    0               }
  100. };
  101.  
  102. void create_print_popup(void)
  103. {
  104.     struct menu    *mp;            /* current menu[] entry */
  105.     WidgetClass    class;            /* label, radio, or button */
  106.     String        cback;            /* activale or valueChanged */
  107.     Widget        form, w=0, rowcol=0, sep;
  108.     Arg        args[20];
  109.     int        n;
  110.     Atom        closewindow;
  111.  
  112.     destroy_print_popup();
  113.  
  114.     n = 0;
  115.     XtSetArg(args[n], XmNdeleteResponse,    XmDO_NOTHING);        n++;
  116.     XtSetArg(args[n], XmNiconic,        False);            n++;
  117.     shell = XtAppCreateShell("Grok Print", "Grok",
  118.             applicationShellWidgetClass, display, args, n);
  119.     set_icon(shell, 1);
  120.     form = XtCreateManagedWidget("prefform", xmFormWidgetClass,
  121.             shell, NULL, 0);
  122.     XtAddCallback(form, XmNhelpCallback,
  123.             (XtCallbackProc)help_callback, (XtPointer)"print");
  124.  
  125.     for (mp=menu; mp->type; mp++) {
  126.         class = xmLabelWidgetClass;
  127.         cback = 0;
  128.         n = 0;
  129.         if (mp->type == 'L')
  130.         w = rowcol;
  131.         if (w == 0) {
  132.         XtSetArg(args[n], XmNtopAttachment,  XmATTACH_FORM);    n++;
  133.         } else {
  134.         XtSetArg(args[n], XmNtopAttachment,  XmATTACH_WIDGET);    n++;
  135.         XtSetArg(args[n], XmNtopWidget,      w);        n++;
  136.         }
  137.         if (mp->type == 'R') {
  138.         XtSetArg(args[n], XmNradioBehavior,  True);        n++;
  139.         XtSetArg(args[n], XmNradioAlwaysOne, True);        n++;
  140.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);    n++;
  141.         XtSetArg(args[n], XmNleftOffset,     32);        n++;
  142.         class = xmRowColumnWidgetClass;
  143.         } else {
  144.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);    n++;
  145.         XtSetArg(args[n], XmNtopOffset,         8);        n++;
  146.         XtSetArg(args[n], XmNleftOffset,     16);        n++;
  147.         }
  148.         if (mp->type == 'C') {
  149.         XtSetArg(args[n], XmNset,      *mp->ptr==mp->value);    n++;
  150.         XtSetArg(args[n], XmNfillOnSelect,   True);        n++;
  151.         XtSetArg(args[n], XmNselectColor,    color[COL_TOGGLE]);n++;
  152.         class = xmToggleButtonWidgetClass;
  153.         cback = XmNvalueChangedCallback;
  154.         }
  155.         if (mp->code == 0x32) { /*<<<*/
  156.         XtSetArg(args[n], XmNsensitive,         FALSE);        n++;
  157.         }
  158.         XtSetArg(args[n], XmNhighlightThickness, 0);        n++;
  159.         w = mp->widget = XtCreateManagedWidget(mp->text, class,
  160.                     mp->type == 'C' ? rowcol : form, args, n);
  161.         if (cback)
  162.         XtAddCallback(w, cback,
  163.             (XtCallbackProc)config_callback, (XtPointer)mp->code);
  164.         if (mp->type == 'R') {
  165.         rowcol = w;
  166.         w = 0;
  167.         }
  168.     }
  169.                             /*-- buttons --*/
  170.     n = 0;
  171.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
  172.     XtSetArg(args[n], XmNtopWidget,        w);            n++;
  173.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  174.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  175.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  176.     sep = XtCreateManagedWidget("ps",xmSeparatorWidgetClass,form,args,n);
  177.  
  178.     n = 0;
  179.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
  180.     XtSetArg(args[n], XmNtopWidget,        sep);            n++;
  181.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  182.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  183.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  184.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM);        n++;
  185.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  186.     XtSetArg(args[n], XmNwidth,        80);            n++;
  187.     w = XtCreateManagedWidget("Print",xmPushButtonWidgetClass,form,args,n);
  188.     XtAddCallback(w, XmNactivateCallback,
  189.             (XtCallbackProc)print_callback, NULL);
  190.  
  191.     n = 0;
  192.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
  193.     XtSetArg(args[n], XmNtopWidget,        sep);            n++;
  194.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  195.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  196.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  197.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  198.     XtSetArg(args[n], XmNleftWidget,    w);            n++;
  199.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  200.     XtSetArg(args[n], XmNwidth,        80);            n++;
  201.     w = XtCreateManagedWidget("Cancel",xmPushButtonWidgetClass,form,args,n);
  202.     XtAddCallback(w, XmNactivateCallback,
  203.             (XtCallbackProc)cancel_callback, NULL);
  204.  
  205.     n = 0;
  206.     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
  207.     XtSetArg(args[n], XmNtopWidget,        sep);            n++;
  208.     XtSetArg(args[n], XmNtopOffset,        8);            n++;
  209.     XtSetArg(args[n], XmNbottomAttachment,    XmATTACH_FORM);        n++;
  210.     XtSetArg(args[n], XmNbottomOffset,    8);            n++;
  211.     XtSetArg(args[n], XmNleftAttachment,    XmATTACH_WIDGET);    n++;
  212.     XtSetArg(args[n], XmNleftWidget,    w);            n++;
  213.     XtSetArg(args[n], XmNleftOffset,    8);            n++;
  214.     XtSetArg(args[n], XmNrightAttachment,    XmATTACH_FORM);        n++;
  215.     XtSetArg(args[n], XmNrightOffset,    8);            n++;
  216.     XtSetArg(args[n], XmNwidth,        80);            n++;
  217.     w = XtCreateManagedWidget("Help",xmPushButtonWidgetClass,form,args,n);
  218.     XtAddCallback(w, XmNactivateCallback,
  219.             (XtCallbackProc)help_callback, (XtPointer)"print");
  220.  
  221.     XtPopup(shell, XtGrabNone);
  222.     closewindow = XmInternAtom(display, "WM_DELETE_WINDOW", False);
  223.     XmAddWMProtocolCallback(shell, closewindow,
  224.             (XtCallbackProc)cancel_callback, NULL);
  225.     have_shell = TRUE;
  226.     modified = FALSE;
  227. }
  228.  
  229.  
  230. /*-------------------------------------------------- callbacks --------------*/
  231. /*
  232.  * All of these routines are direct X callbacks.
  233.  */
  234.  
  235. /*ARGSUSED*/
  236. static void cancel_callback(
  237.     Widget                widget,
  238.     int                item,
  239.     XmToggleButtonCallbackStruct    *data)
  240. {
  241.     destroy_print_popup();
  242. }
  243.  
  244.  
  245. /*ARGSUSED*/
  246. static void print_callback(
  247.     Widget                widget,
  248.     int                item,
  249.     XmToggleButtonCallbackStruct    *data)
  250. {
  251.     Arg        args[20];
  252.     int        n = 0;
  253.     Widget        w;
  254.  
  255.     if (pref.pdevice == 'F') {
  256.         /*
  257.         XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  258.         */
  259.         w = XmCreateFileSelectionDialog(shell, "pfile", args, n);
  260.         XtAddCallback(w, XmNokCallback,
  261.                 (XtCallbackProc)file_print_callback, 0);
  262.         XtAddCallback(w, XmNcancelCallback,
  263.                 (XtCallbackProc)file_cancel_callback, 0);
  264.         XtManageChild(w);
  265.         return;
  266.     }
  267.     print();
  268.     destroy_print_popup();
  269. }
  270.  
  271.  
  272. /*ARGSUSED*/
  273. static void file_print_callback(
  274.     Widget                widget,
  275.     int                item,
  276.     XmFileSelectionBoxCallbackStruct*data)
  277. {
  278.     char    *p = 0;
  279.  
  280.     if (!XmStringGetLtoR(data->value,XmSTRING_DEFAULT_CHARSET,&p) || !*p) {
  281.         create_error_popup(shell, 0, "No file name, aborted.");
  282.         if (p) XtFree(p);
  283.         return;
  284.     }
  285.     if (pref.pfile)
  286.         free(pref.pfile);
  287.     pref.pfile = mystrdup(p);
  288.     print();
  289.     XtFree(p);
  290.     destroy_print_popup();
  291. }
  292.  
  293.  
  294. /*ARGSUSED*/
  295. static void file_cancel_callback(
  296.     Widget                widget,
  297.     int                item,
  298.     XmFileSelectionBoxCallbackStruct*data)
  299. {
  300.     XtDestroyWidget(widget);
  301. }
  302.  
  303.  
  304. /*ARGSUSED*/
  305. static void config_callback(
  306.     Widget                widget,
  307.     int                code,
  308.     XmToggleButtonCallbackStruct    *data)
  309. {
  310.     struct menu            *mp;
  311.  
  312.     for (mp=menu; mp->type; mp++)
  313.         if (code == mp->code)
  314.             break;
  315.     if (!mp->type)
  316.         return;
  317.     *mp->ptr = mp->value;
  318.     modified = TRUE;
  319. }
  320.